<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>scalation.process.WaitQueue</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link type="text/css" media="screen" rel="stylesheet" href="../../lib/template.css" />
      <script type="text/javascript" src="../../lib/jquery.js"></script>
      <script type="text/javascript" src="../../lib/jquery-ui.js"></script>
      <script type="text/javascript" src="../../lib/template.js"></script>
      <script type="text/javascript" src="../../lib/tools.tooltip.js"></script>
    
        </head>
        <body class="type">
      <div id="definition">
        <img src="../../lib/class_big.png" />
        <p id="owner"><a name="scalation" class="extype" href="../package.html">scalation</a>.<a name="scalation.process" class="extype" href="package.html">process</a></p>
        <h1>WaitQueue</h1>
      </div>

      <h4 class="signature" id="signature">
      <span class="kind">class</span>
      <span class="symbol"> 
        <span class="name">WaitQueue</span>
        
        <span class="result"> extends <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>] with <a name="scalation.process.Component" class="extype" href="Component.html">Component</a></span>
      </span>
      </h4>
      
          <div class="fullcommenttop" id="comment"><div class="comment cmt"><p>The WaitQueue class simply a wrapper for monitoring scala's Queue class.</p></div><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><a name="scalation.process.Component" class="extype" href="Component.html">Component</a>, <a name="scalation.util.Identity" class="extype" href="../util/Identity.html">Identity</a>, <a name="scalation.util.Error" class="extype" href="../util/Error.html">Error</a>, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.Serializable" class="extype">Serializable</span>, <span name="java.io.Serializable" class="extype">Serializable</span>, <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.generic.Growable" class="extype">Growable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.LinearSeqOptimized" class="extype">LinearSeqOptimized</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.mutable.LinearSeq" class="extype">LinearSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.LinearSeq" class="extype">LinearSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.LinearSeqLike" class="extype">LinearSeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.mutable.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.mutable.SeqLike" class="extype">SeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.mutable.Cloneable" class="extype">Cloneable</span>[<span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.SeqLike" class="extype">SeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.GenSeqLike" class="extype">GenSeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Int" class="extype">Int</span>, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], (<span name="scala.Int" class="extype">Int</span>) ⇒ <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.Iterable" class="extype">Iterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.IterableLike" class="extype">IterableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.Equals" class="extype">Equals</span>, <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.GenIterableLike" class="extype">GenIterableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.mutable.Traversable" class="extype">Traversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.Mutable" class="extype">Mutable</span>, <span name="scala.collection.Traversable" class="extype">Traversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.GenTraversable" class="extype">GenTraversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.generic.GenericTraversableTemplate" class="extype">GenericTraversableTemplate</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>], <span name="scala.collection.TraversableLike" class="extype">TraversableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.GenTraversableLike" class="extype">GenTraversableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.Parallelizable" class="extype">Parallelizable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.parallel.mutable.ParSeq" class="extype">ParSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], <span name="scala.collection.generic.HasNewBuilder" class="extype">HasNewBuilder</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]], AnyRef, <span name="scala.Any" class="extype">Any</span></div>
        </div></div>
        

      <div id="template">

        <div id="mbrsel">
          <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div>
          <div id="order">
                <span class="filtertype">Ordering</span>
                <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol>
              </div>
          <div id="ancestors">
                <span class="filtertype">Inherited</span>
                <ol><li class="hideall out"><span>Hide All</span></li>
                <li class="showall in"><span>Show all</span></li></ol>
                <ol id="linearization"><li name="scalation.process.WaitQueue" class="in"><span>WaitQueue</span></li><li name="scalation.process.Component" class="in"><span>Component</span></li><li name="scalation.util.Identity" class="in"><span>Identity</span></li><li name="scalation.util.Error" class="in"><span>Error</span></li><li name="scala.collection.mutable.Queue" class="in"><span>Queue</span></li><li name="scala.collection.mutable.MutableList" class="in"><span>MutableList</span></li><li name="scala.Serializable" class="in"><span>Serializable</span></li><li name="java.io.Serializable" class="in"><span>Serializable</span></li><li name="scala.collection.mutable.Builder" class="in"><span>Builder</span></li><li name="scala.collection.generic.Growable" class="in"><span>Growable</span></li><li name="scala.collection.LinearSeqOptimized" class="in"><span>LinearSeqOptimized</span></li><li name="scala.collection.mutable.LinearSeq" class="in"><span>LinearSeq</span></li><li name="scala.collection.LinearSeq" class="in"><span>LinearSeq</span></li><li name="scala.collection.LinearSeqLike" class="in"><span>LinearSeqLike</span></li><li name="scala.collection.mutable.Seq" class="in"><span>Seq</span></li><li name="scala.collection.mutable.SeqLike" class="in"><span>SeqLike</span></li><li name="scala.collection.mutable.Cloneable" class="in"><span>Cloneable</span></li><li name="scala.collection.Seq" class="in"><span>Seq</span></li><li name="scala.collection.SeqLike" class="in"><span>SeqLike</span></li><li name="scala.collection.GenSeq" class="in"><span>GenSeq</span></li><li name="scala.collection.GenSeqLike" class="in"><span>GenSeqLike</span></li><li name="scala.PartialFunction" class="in"><span>PartialFunction</span></li><li name="scala.Function1" class="in"><span>Function1</span></li><li name="scala.collection.mutable.Iterable" class="in"><span>Iterable</span></li><li name="scala.collection.Iterable" class="in"><span>Iterable</span></li><li name="scala.collection.IterableLike" class="in"><span>IterableLike</span></li><li name="scala.Equals" class="in"><span>Equals</span></li><li name="scala.collection.GenIterable" class="in"><span>GenIterable</span></li><li name="scala.collection.GenIterableLike" class="in"><span>GenIterableLike</span></li><li name="scala.collection.mutable.Traversable" class="in"><span>Traversable</span></li><li name="scala.Mutable" class="in"><span>Mutable</span></li><li name="scala.collection.Traversable" class="in"><span>Traversable</span></li><li name="scala.collection.GenTraversable" class="in"><span>GenTraversable</span></li><li name="scala.collection.generic.GenericTraversableTemplate" class="in"><span>GenericTraversableTemplate</span></li><li name="scala.collection.TraversableLike" class="in"><span>TraversableLike</span></li><li name="scala.collection.GenTraversableLike" class="in"><span>GenTraversableLike</span></li><li name="scala.collection.Parallelizable" class="in"><span>Parallelizable</span></li><li name="scala.collection.TraversableOnce" class="in"><span>TraversableOnce</span></li><li name="scala.collection.GenTraversableOnce" class="in"><span>GenTraversableOnce</span></li><li name="scala.collection.generic.FilterMonadic" class="in"><span>FilterMonadic</span></li><li name="scala.collection.generic.HasNewBuilder" class="in"><span>HasNewBuilder</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol>
              </div>
          <div id="visbl">
              <span class="filtertype">Visibility</span>
              <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
            </div>
        </div>

        <div class="members" id="constructors">
              <h3>Instance Constructors</h3>
              <ol><li visbl="pub" name="scalation.process.WaitQueue#this" data-isabs="false">
      <a id="this:WaitQueue"></a>
      <h4 class="signature">
      <span class="kind">new</span>
      <span class="symbol"> 
        <span class="name">WaitQueue</span>
        
        <span class="params">(<span name="name">name: String</span>, <span name="xy">xy: (<span name="scala.Double" class="extype">Double</span>, <span name="scala.Double" class="extype">Double</span>)</span>)</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Auxiliary constuctor that uses defaults for width (w) and height (h).</p><div class="fullcomment"><div class="comment cmt"><p>Auxiliary constuctor that uses defaults for width (w) and height (h).</p></div><dl class="paramcmts block"><dt class="param">name</dt><dd class="cmt"><p>the name of the wait-queue</p></dd><dt class="param">xy</dt><dd class="cmt"><p>the (x, y) coordinates for the top-left corner of the wait-queue.
</p></dd></dl></div>
    </li><li visbl="pub" name="scalation.process.WaitQueue#this" data-isabs="false">
      <a id="this:WaitQueue"></a>
      <h4 class="signature">
      <span class="kind">new</span>
      <span class="symbol"> 
        <span class="name">WaitQueue</span>
        
        <span class="params">(<span name="name">name: String</span>, <span name="at">at: <span name="scala.Array" class="extype">Array</span>[<span name="scala.Double" class="extype">Double</span>]</span>)</span>
      </span>
      </h4>
      <p class="shortcomment cmt"></p><div class="fullcomment"><div class="comment cmt"></div><dl class="paramcmts block"><dt class="param">name</dt><dd class="cmt"><p>the name of the wait-queue</p></dd><dt class="param">at</dt><dd class="cmt"><p>the location of the wait-queue (x, y, w, h)
</p></dd></dl></div>
    </li></ol>
            </div>

        <div class="types members" id="types">
              <h3>Type Members</h3>
              <ol><li visbl="prt" name="scala.collection.TraversableLike#Self" data-isabs="false">
      <a id="Self:Self"></a>
      <h4 class="signature">
      <span class="kind">type</span>
      <span class="symbol"> 
        <span class="name">Self</span>
        
        <span class="result"> = <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li></ol>
            </div>
        
        

        <div class="values members" id="values">
              <h3>Value Members</h3>
              <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false">
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#!=" data-isabs="false">
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false">
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">##</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++" data-isabs="false">
      <a id="++[B&gt;:SimActor, That](TraversableOnce[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">++</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++" data-isabs="false">
      <a id="++[B&gt;:SimActor, That](GenTraversableOnce[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">++</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++:" data-isabs="false">
      <a id="++:[B&gt;:SimActor, That](Traversable[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">++:</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Traversable" class="extype">Traversable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++:" data-isabs="false">
      <a id="++:[B&gt;:SimActor, That](TraversableOnce[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">++:</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.Growable#++=" data-isabs="false">
      <a id="++=(TraversableOnce[SimActor]):WaitQueue.this.type"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">++=</span>
        
        <span class="params">(<span name="xs">xs: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>)</span><span class="result">: WaitQueue.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#+:" data-isabs="false">
      <a id="+:[B&gt;:SimActor, That](B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">+:</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#+=" data-isabs="false">
      <a id="+=(SimActor):WaitQueue.this.type"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">+=</span>
        
        <span class="params">(<span name="elem">elem: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>)</span><span class="result">: WaitQueue.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → Builder → Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.Growable#+=" data-isabs="false">
      <a id="+=(SimActor,SimActor,SimActor*):WaitQueue.this.type"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">+=</span>
        
        <span class="params">(<span name="elem1">elem1: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="elem2">elem2: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="elems">elems: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>*</span>)</span><span class="result">: WaitQueue.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#+=:" data-isabs="false">
      <a id="+=:(SimActor):WaitQueue.this.type"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">+=:</span>
        
        <span class="params">(<span name="elem">elem: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>)</span><span class="result">: WaitQueue.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#/:" data-isabs="false">
      <a id="/:[B](B)((B, SimActor) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">/:</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableOnce#/:\" data-isabs="false">
      <a id="/:\[A1&gt;:SimActor](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">/:\</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#:+" data-isabs="false">
      <a id=":+[B&gt;:SimActor, That](B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">:+</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#:\" data-isabs="false">
      <a id=":\[B](B)((SimActor, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">:\</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false">
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#==" data-isabs="false">
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#DIAM" data-isabs="false">
      <a id="DIAM:Double"></a>
      <h4 class="signature">
      <span class="kind">val</span>
      <span class="symbol"> 
        <span class="name">DIAM</span>
        
        <span class="result">: <span name="scala.Double" class="extype">Double</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Diameter of a token (for animating entities)
</p><div class="fullcomment"><div class="comment cmt"><p>Diameter of a token (for animating entities)
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#RAD" data-isabs="false">
      <a id="RAD:Double"></a>
      <h4 class="signature">
      <span class="kind">val</span>
      <span class="symbol"> 
        <span class="name">RAD</span>
        
        <span class="result">: <span name="scala.Double" class="extype">Double</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Radius of a token (for animating entities)
</p><div class="fullcomment"><div class="comment cmt"><p>Radius of a token (for animating entities)
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#accumulate" data-isabs="false">
      <a id="accumulate(Double,Double):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">accumulate</span>
        
        <span class="params">(<span name="value">value: <span name="scala.Double" class="extype">Double</span></span>, <span name="time">time: <span name="scala.Double" class="extype">Double</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Accumulate the value (e.</p><div class="fullcomment"><div class="comment cmt"><p>Accumulate the value (e.g., number in  queue) weighted by its time duration.</p></div><dl class="paramcmts block"><dt class="param">value</dt><dd class="cmt"><p>the value to accumulate</p></dd><dt class="param">time</dt><dd class="cmt"><p>the current time of the observation
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder):StringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">addString</span>
        
        <span class="params">(<span name="b">b: StringBuilder</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">addString</span>
        
        <span class="params">(<span name="b">b: StringBuilder</span>, <span name="sep">sep: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String,String,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">addString</span>
        
        <span class="params">(<span name="b">b: StringBuilder</span>, <span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#aggregate" data-isabs="false">
      <a id="aggregate[B](B)((B, SimActor) ⇒ B,(B, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">aggregate</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="seqop">seqop: (B, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>, <span name="combop">combop: (B, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#andThen" data-isabs="false">
      <a id="andThen[C]((SimActor) ⇒ C):PartialFunction[Int, C]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">andThen</span>
        <span class="tparams">[<span name="C">C</span>]</span>
        <span class="params">(<span name="k">k: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ C</span>)</span><span class="result">: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Int" class="extype">Int</span>, C]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction → Function1</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MutableList#appendElem" data-isabs="false">
      <a id="appendElem(SimActor):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">appendElem</span>
        
        <span class="params">(<span name="elem">elem: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#apply" data-isabs="false">
      <a id="apply(Int):SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">apply</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqOptimized → SeqLike → GenSeqLike → Function1</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false">
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">asInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#canEqual" data-isabs="false">
      <a id="canEqual(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">canEqual</span>
        
        <span class="params">(<span name="that">that: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → Equals</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#clear" data-isabs="false">
      <a id="clear():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">clear</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → Builder → Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Cloneable#clone" data-isabs="false">
      <a id="clone():Queue[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">clone</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Cloneable → AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#collect" data-isabs="false">
      <a id="collect[B, That](PartialFunction[SimActor, B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">collect</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#collectFirst" data-isabs="false">
      <a id="collectFirst[B](PartialFunction[SimActor, B]):Option[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">collectFirst</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B]</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#combinations" data-isabs="false">
      <a id="combinations(Int):Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">combinations</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#companion" data-isabs="false">
      <a id="companion:GenericCompanion[Queue]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">companion</span>
        
        <span class="result">: <span name="scala.collection.generic.GenericCompanion" class="extype">GenericCompanion</span>[<span name="scala.collection.mutable.Queue" class="extype">Queue</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue → MutableList → LinearSeq → LinearSeq → Seq → Seq → GenSeq → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.Function1#compose" data-isabs="false">
      <a id="compose[A]((A) ⇒ Int):(A) ⇒ SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">compose</span>
        <span class="tparams">[<span name="A">A</span>]</span>
        <span class="params">(<span name="g">g: (A) ⇒ <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: (A) ⇒ <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Function1</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#contains" data-isabs="false">
      <a id="contains(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">contains</span>
        
        <span class="params">(<span name="elem">elem: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#containsSlice" data-isabs="false">
      <a id="containsSlice[B](Seq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">containsSlice</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#containsSlice" data-isabs="false">
      <a id="containsSlice[B](GenSeq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">containsSlice</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:SimActor](Array[B],Int,Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">copyToArray</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>, <span name="len">len: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:SimActor](Array[B]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">copyToArray</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:SimActor](Array[B],Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">copyToArray</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToBuffer" data-isabs="false">
      <a id="copyToBuffer[B&gt;:SimActor](Buffer[B]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">copyToBuffer</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="dest">dest: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#corresponds" data-isabs="false">
      <a id="corresponds[B](Seq[B])((SimActor, B) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">corresponds</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#corresponds" data-isabs="false">
      <a id="corresponds[B](GenSeq[B])((SimActor, B) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">corresponds</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#count" data-isabs="false">
      <a id="count((SimActor) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">count</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#dequeue" data-isabs="false">
      <a id="dequeue():SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">dequeue</span>
        
        <span class="params">()</span><span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#dequeueAll" data-isabs="false">
      <a id="dequeueAll((SimActor) ⇒ Boolean):Seq[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">dequeueAll</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#dequeueFirst" data-isabs="false">
      <a id="dequeueFirst((SimActor) ⇒ Boolean):Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">dequeueFirst</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#diff" data-isabs="false">
      <a id="diff[B&gt;:SimActor](Seq[B]):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">diff</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#diff" data-isabs="false">
      <a id="diff[B&gt;:SimActor](GenSeq[B]):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">diff</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#director" data-isabs="false">
      <a id="director:Model"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">director</span>
        
        <span class="result">: <a name="scalation.process.Model" class="extype" href="Model.html">Model</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Return the director who controls the play/simulation this component is in.</p><div class="fullcomment"><div class="comment cmt"><p>Return the director who controls the play/simulation this component is in.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.process.WaitQueue#display" data-isabs="false">
      <a id="display():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">display</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Tell the animation queue to display this WaitQueue.</p><div class="fullcomment"><div class="comment cmt"><p>Tell the animation queue to display this WaitQueue.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.WaitQueue" class="extype" href="">WaitQueue</a> → <a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#distinct" data-isabs="false">
      <a id="distinct:MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">distinct</span>
        
        <span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#drop" data-isabs="false">
      <a id="drop(Int):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">drop</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#dropRight" data-isabs="false">
      <a id="dropRight(Int):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">dropRight</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#dropWhile" data-isabs="false">
      <a id="dropWhile((SimActor) ⇒ Boolean):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">dropWhile</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#durationStat" data-isabs="false">
      <a id="durationStat:Statistic"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">durationStat</span>
        
        <span class="result">: <a name="scalation.stat.Statistic" class="extype" href="../stat/Statistic.html">Statistic</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Return sample statistics for durations for this component (e.</p><div class="fullcomment"><div class="comment cmt"><p>Return sample statistics for durations for this component (e.g., Time in queue).
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#endsWith" data-isabs="false">
      <a id="endsWith[B](Seq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">endsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#endsWith" data-isabs="false">
      <a id="endsWith[B](GenSeq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">endsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#enqueue" data-isabs="false">
      <a id="enqueue(SimActor*):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">enqueue</span>
        
        <span class="params">(<span name="elems">elems: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>*</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false">
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">eq</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#equals" data-isabs="false">
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">equals</span>
        
        <span class="params">(<span name="that">that: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike → Equals → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#exists" data-isabs="false">
      <a id="exists((SimActor) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">exists</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#extractFirst" data-isabs="false">
      <a id="extractFirst(LinkedList[SimActor],(SimActor) ⇒ Boolean):Option[LinkedList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">extractFirst</span>
        
        <span class="params">(<span name="start">start: <span name="scala.collection.mutable.LinkedList" class="extype">LinkedList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>, <span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<span name="scala.collection.mutable.LinkedList" class="extype">LinkedList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#filter" data-isabs="false">
      <a id="filter((SimActor) ⇒ Boolean):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">filter</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#filterNot" data-isabs="false">
      <a id="filterNot((SimActor) ⇒ Boolean):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">filterNot</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false">
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">finalize</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#find" data-isabs="false">
      <a id="find((SimActor) ⇒ Boolean):Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">find</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MutableList#first0" data-isabs="false">
      <a id="first0:LinkedList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">var</span>
      <span class="symbol"> 
        <span class="name">first0</span>
        
        <span class="result">: <span name="scala.collection.mutable.LinkedList" class="extype">LinkedList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#flatMap" data-isabs="false">
      <a id="flatMap[B, That]((SimActor) ⇒ GenTraversableOnce[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">flatMap</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Traversable#flatten" data-isabs="false">
      <a id="flatten[B]((SimActor) ⇒ TraversableOnce[B]):Traversable[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">flatten</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asTraversable">asTraversable: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Traversable → GenericTraversableTemplate</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scalation.util.Error#flaw" data-isabs="false">
      <a id="flaw(String,String):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">flaw</span>
        
        <span class="params">(<span name="method">method: String</span>, <span name="message">message: String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Show the flaw by printing the error message.</p><div class="fullcomment"><div class="comment cmt"><p>:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Show the flaw by printing the error message.</p></div><dl class="paramcmts block"><dt class="param">method</dt><dd class="cmt"><p>the method where the error occured</p></dd><dt class="param">message</dt><dd class="cmt"><p>the error message
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.util.Error" class="extype" href="../util/Error.html">Error</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#fold" data-isabs="false">
      <a id="fold[A1&gt;:SimActor](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">fold</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#foldLeft" data-isabs="false">
      <a id="foldLeft[B](B)((B, SimActor) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">foldLeft</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="f">f: (B, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#foldRight" data-isabs="false">
      <a id="foldRight[B](B)((SimActor, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">foldRight</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#forall" data-isabs="false">
      <a id="forall((SimActor) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">forall</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#foreach" data-isabs="false">
      <a id="foreach[B]((SimActor) ⇒ B):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">foreach</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Queue#front" data-isabs="false">
      <a id="front:SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">front</span>
        
        <span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Queue</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#genericBuilder" data-isabs="false">
      <a id="genericBuilder[B]:Builder[B, Queue[B]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">genericBuilder</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[B, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[B]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#get" data-isabs="false">
      <a id="get(Int):Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">get</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false">
      <a id="getClass():java.lang.Class[_]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">getClass</span>
        
        <span class="params">()</span><span class="result">: java.lang.Class[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#groupBy" data-isabs="false">
      <a id="groupBy[K]((SimActor) ⇒ K):Map[K, MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">groupBy</span>
        <span class="tparams">[<span name="K">K</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ K</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[K, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#grouped" data-isabs="false">
      <a id="grouped(Int):Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">grouped</span>
        
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#hasDefiniteSize" data-isabs="false">
      <a id="hasDefiniteSize:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">hasDefiniteSize</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#hashCode" data-isabs="false">
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">hashCode</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#head" data-isabs="false">
      <a id="head:SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">head</span>
        
        <span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqOptimized → IterableLike → GenIterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#headOption" data-isabs="false">
      <a id="headOption:Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">headOption</span>
        
        <span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scalation.util.Identity#id" data-isabs="false">
      <a id="id:Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">id</span>
        
        <span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Get the id (unique identifier).</p><div class="fullcomment"><div class="comment cmt"><p>Get the id (unique identifier).
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.util.Identity" class="extype" href="../util/Identity.html">Identity</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#indexOf" data-isabs="false">
      <a id="indexOf[B&gt;:SimActor](B,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#indexOf" data-isabs="false">
      <a id="indexOf[B&gt;:SimActor](B):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:SimActor](Seq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:SimActor](GenSeq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:SimActor](Seq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:SimActor](GenSeq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#indexWhere" data-isabs="false">
      <a id="indexWhere((SimActor) ⇒ Boolean,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexWhere</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#indexWhere" data-isabs="false">
      <a id="indexWhere((SimActor) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indexWhere</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indices" data-isabs="false">
      <a id="indices:Range"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">indices</span>
        
        <span class="result">: <span name="scala.collection.immutable.Range" class="extype">Range</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#init" data-isabs="false">
      <a id="init:MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">init</span>
        
        <span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#initComponent" data-isabs="false">
      <a id="initComponent(String,Array[Double]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">initComponent</span>
        
        <span class="params">(<span name="label">label: String</span>, <span name="loc">loc: <span name="scala.Array" class="extype">Array</span>[<span name="scala.Double" class="extype">Double</span>]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Initialize this component (all of its vars).</p><div class="fullcomment"><div class="comment cmt"><p>Initialize this component (all of its vars).</p></div><dl class="paramcmts block"><dt class="param">label</dt><dd class="cmt"><p>the name of this component</p></dd><dt class="param">loc</dt><dd class="cmt"><p>the location of this component
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#initStats" data-isabs="false">
      <a id="initStats(String):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">initStats</span>
        
        <span class="params">(<span name="label">label: String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Initialize this component's statistical collectors.</p><div class="fullcomment"><div class="comment cmt"><p>Initialize this component's statistical collectors.</p></div><dl class="paramcmts block"><dt class="param">label</dt><dd class="cmt"><p>the name of this component
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#inits" data-isabs="false">
      <a id="inits:Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">inits</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#intersect" data-isabs="false">
      <a id="intersect[B&gt;:SimActor](Seq[B]):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">intersect</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#intersect" data-isabs="false">
      <a id="intersect[B&gt;:SimActor](GenSeq[B]):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">intersect</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#isDefinedAt" data-isabs="false">
      <a id="isDefinedAt(Int):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">isDefinedAt</span>
        
        <span class="params">(<span name="x">x: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#isEmpty" data-isabs="false">
      <a id="isEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">isEmpty</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqOptimized → IterableLike → GenIterableLike → GenericTraversableTemplate → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">isInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableLike#isTraversableAgain" data-isabs="false">
      <a id="isTraversableAgain:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">isTraversableAgain</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>GenTraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#iterator" data-isabs="false">
      <a id="iterator:Iterator[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">iterator</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqLike → IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#last" data-isabs="false">
      <a id="last:SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">last</span>
        
        <span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqOptimized → TraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MutableList#last0" data-isabs="false">
      <a id="last0:LinkedList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">var</span>
      <span class="symbol"> 
        <span class="name">last0</span>
        
        <span class="result">: <span name="scala.collection.mutable.LinkedList" class="extype">LinkedList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#lastIndexOf" data-isabs="false">
      <a id="lastIndexOf[B&gt;:SimActor](B,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#lastIndexOf" data-isabs="false">
      <a id="lastIndexOf[B&gt;:SimActor](B):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:SimActor](Seq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:SimActor](GenSeq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:SimActor](Seq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:SimActor](GenSeq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#lastIndexWhere" data-isabs="false">
      <a id="lastIndexWhere((SimActor) ⇒ Boolean,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexWhere</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#lastIndexWhere" data-isabs="false">
      <a id="lastIndexWhere((SimActor) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastIndexWhere</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#lastOption" data-isabs="false">
      <a id="lastOption:Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lastOption</span>
        
        <span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MutableList#len" data-isabs="false">
      <a id="len:Int"></a>
      <h4 class="signature">
      <span class="kind">var</span>
      <span class="symbol"> 
        <span class="name">len</span>
        
        <span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#length" data-isabs="false">
      <a id="length:Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">length</span>
        
        <span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#lengthCompare" data-isabs="false">
      <a id="lengthCompare(Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lengthCompare</span>
        
        <span class="params">(<span name="len">len: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#lift" data-isabs="false">
      <a id="lift:(Int) ⇒ Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">lift</span>
        
        <span class="result">: (<span name="scala.Int" class="extype">Int</span>) ⇒ <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#map" data-isabs="false">
      <a id="map[B, That]((SimActor) ⇒ B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">map</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#mapResult" data-isabs="false">
      <a id="mapResult[NewTo]((MutableList[SimActor]) ⇒ NewTo):Builder[SimActor, NewTo]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">mapResult</span>
        <span class="tparams">[<span name="NewTo">NewTo</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]) ⇒ NewTo</span>)</span><span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, NewTo]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#max" data-isabs="false">
      <a id="max[B&gt;:SimActor](Ordering[B]):SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">max</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#maxBy" data-isabs="false">
      <a id="maxBy[B]((SimActor) ⇒ B)(Ordering[B]):SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">maxBy</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scalation.util.Identity#me" data-isabs="false">
      <a id="me:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">me</span>
        
        <span class="result">: <span name="java.lang.String" class="extype">String</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Return the full identity.</p><div class="fullcomment"><div class="comment cmt"><p>Return the full identity.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.util.Identity" class="extype" href="../util/Identity.html">Identity</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#min" data-isabs="false">
      <a id="min[B&gt;:SimActor](Ordering[B]):SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">min</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#minBy" data-isabs="false">
      <a id="minBy[B]((SimActor) ⇒ B)(Ordering[B]):SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">minBy</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">mkString</span>
        
        <span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String):String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">mkString</span>
        
        <span class="params">(<span name="sep">sep: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String,String,String):String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">mkString</span>
        
        <span class="params">(<span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false">
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">ne</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.Queue#newBuilder" data-isabs="false">
      <a id="newBuilder:Builder[SimActor, Queue[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">newBuilder</span>
        
        <span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>Queue → MutableList → GenericTraversableTemplate → TraversableLike → HasNewBuilder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#nonEmpty" data-isabs="false">
      <a id="nonEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">nonEmpty</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false">
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">notify</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false">
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">notifyAll</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#orElse" data-isabs="false">
      <a id="orElse[A1&lt;:Int, B1&gt;:SimActor](PartialFunction[A1, B1]):PartialFunction[A1, B1]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">orElse</span>
        <span class="tparams">[<span name="A1">A1 &lt;: <span name="scala.Int" class="extype">Int</span></span>, <span name="B1">B1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[A1, B1]</span>)</span><span class="result">: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[A1, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#padTo" data-isabs="false">
      <a id="padTo[B&gt;:SimActor, That](Int,B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">padTo</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="len">len: <span name="scala.Int" class="extype">Int</span></span>, <span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Parallelizable#par" data-isabs="false">
      <a id="par:ParSeq[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">par</span>
        
        <span class="result">: <span name="scala.collection.parallel.mutable.ParSeq" class="extype">ParSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Parallelizable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.SeqLike#parCombiner" data-isabs="false">
      <a id="parCombiner:Combiner[SimActor, ParSeq[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">parCombiner</span>
        
        <span class="result">: <span name="scala.collection.parallel.Combiner" class="extype">Combiner</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.parallel.mutable.ParSeq" class="extype">ParSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>SeqLike → SeqLike → TraversableLike → Parallelizable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#partition" data-isabs="false">
      <a id="partition((SimActor) ⇒ Boolean):(MutableList[SimActor], MutableList[SimActor])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">partition</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#patch" data-isabs="false">
      <a id="patch[B&gt;:SimActor, That](Int,Seq[B],Int)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">patch</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="patch">patch: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="replaced">replaced: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#patch" data-isabs="false">
      <a id="patch[B&gt;:SimActor, That](Int,GenSeq[B],Int)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">patch</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="patch">patch: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="replaced">replaced: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#permutations" data-isabs="false">
      <a id="permutations:Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">permutations</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#persistentStat" data-isabs="false">
      <a id="persistentStat:TimeStatistic"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">persistentStat</span>
        
        <span class="result">: <a name="scalation.stat.TimeStatistic" class="extype" href="../stat/TimeStatistic.html">TimeStatistic</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Return time persistent statistics for value for this component (e.</p><div class="fullcomment"><div class="comment cmt"><p>Return time persistent statistics for value for this component (e.g. Number in queue).
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#prefixLength" data-isabs="false">
      <a id="prefixLength((SimActor) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">prefixLength</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MutableList#prependElem" data-isabs="false">
      <a id="prependElem(SimActor):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">prependElem</span>
        
        <span class="params">(<span name="elem">elem: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#product" data-isabs="false">
      <a id="product[B&gt;:SimActor](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">product</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduce" data-isabs="false">
      <a id="reduce[A1&gt;:SimActor]((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reduce</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#reduceLeft" data-isabs="false">
      <a id="reduceLeft[B&gt;:SimActor]((B, SimActor) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reduceLeft</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="f">f: (B, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceLeftOption" data-isabs="false">
      <a id="reduceLeftOption[B&gt;:SimActor]((B, SimActor) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reduceLeftOption</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="op">op: (B, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceOption" data-isabs="false">
      <a id="reduceOption[A1&gt;:SimActor]((A1, A1) ⇒ A1):Option[A1]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reduceOption</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[A1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#reduceRight" data-isabs="false">
      <a id="reduceRight[B&gt;:SimActor]((SimActor, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reduceRight</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="op">op: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceRightOption" data-isabs="false">
      <a id="reduceRightOption[B&gt;:SimActor]((SimActor, B) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reduceRightOption</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="op">op: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#repr" data-isabs="false">
      <a id="repr:MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">repr</span>
        
        <span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#result" data-isabs="false">
      <a id="result():MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">result</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#reverse" data-isabs="false">
      <a id="reverse:MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reverse</span>
        
        <span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#reverseIterator" data-isabs="false">
      <a id="reverseIterator:Iterator[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reverseIterator</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#reverseMap" data-isabs="false">
      <a id="reverseMap[B, That]((SimActor) ⇒ B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reverseMap</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.TraversableOnce#reversed" data-isabs="false">
      <a id="reversed:List[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">reversed</span>
        
        <span class="result">: List[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#sameElements" data-isabs="false">
      <a id="sameElements[B&gt;:SimActor](GenIterable[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sameElements</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sameElements" data-isabs="false">
      <a id="sameElements[B&gt;:SimActor](Iterable[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sameElements</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Iterable" class="extype">Iterable</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scan" data-isabs="false">
      <a id="scan[B&gt;:SimActor, That](B)((B, B) ⇒ B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">scan</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, B) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cbf">cbf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scanLeft" data-isabs="false">
      <a id="scanLeft[B, That](B)((B, SimActor) ⇒ B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">scanLeft</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scanRight" data-isabs="false">
      <a id="scanRight[B, That](B)((SimActor, B) ⇒ B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">scanRight</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#segmentLength" data-isabs="false">
      <a id="segmentLength((SimActor) ⇒ Boolean,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">segmentLength</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Seq#seq" data-isabs="false">
      <a id="seq:Seq[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">seq</span>
        
        <span class="result">: <span name="scala.collection.mutable.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Seq → Seq → GenSeq → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#setAt" data-isabs="false">
      <a id="setAt(Array[Double]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">setAt</span>
        
        <span class="params">(<span name="loc">loc: <span name="scala.Array" class="extype">Array</span>[<span name="scala.Double" class="extype">Double</span>]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Set the location of this component.</p><div class="fullcomment"><div class="comment cmt"><p>Set the location of this component.</p></div><dl class="paramcmts block"><dt class="param">loc</dt><dd class="cmt"><p>the location of this component
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#setDirector" data-isabs="false">
      <a id="setDirector(Model):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">setDirector</span>
        
        <span class="params">(<span name="dir">dir: <a name="scalation.process.Model" class="extype" href="Model.html">Model</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Set this component's director (the controller of the simulation model).</p><div class="fullcomment"><div class="comment cmt"><p>Set this component's director (the controller of the simulation model).</p></div><dl class="paramcmts block"><dt class="param">dir</dt><dd class="cmt"><p>the director of the play/simulation
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.util.Identity#setName" data-isabs="false">
      <a id="setName(String):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">setName</span>
        
        <span class="params">(<span name="label">label: String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Set the name.</p><div class="fullcomment"><div class="comment cmt"><p>Set the name.</p></div><dl class="paramcmts block"><dt class="param">label</dt><dd class="cmt"><p>the name to assign
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.util.Identity" class="extype" href="../util/Identity.html">Identity</a></dd></dl></div>
    </li><li visbl="pub" name="scalation.util.Identity#simType" data-isabs="false">
      <a id="simType:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">simType</span>
        
        <span class="result">: <span name="java.lang.String" class="extype">String</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Get the type of the simulation object.</p><div class="fullcomment"><div class="comment cmt"><p>Get the type of the simulation object.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.util.Identity" class="extype" href="../util/Identity.html">Identity</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#size" data-isabs="false">
      <a id="size:Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">size</span>
        
        <span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#sizeHint" data-isabs="false">
      <a id="sizeHint(scala.collection.TraversableLike[_, _],Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sizeHint</span>
        
        <span class="params">(<span name="coll">coll: scala.collection.TraversableLike[_, _]</span>, <span name="delta">delta: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#sizeHint" data-isabs="false">
      <a id="sizeHint(Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sizeHint</span>
        
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#sizeHintBounded" data-isabs="false">
      <a id="sizeHintBounded(Int,scala.collection.TraversableLike[_, _]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sizeHintBounded</span>
        
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>, <span name="boundingColl">boundingColl: scala.collection.TraversableLike[_, _]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#slice" data-isabs="false">
      <a id="slice(Int,Int):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">slice</span>
        
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sliding" data-isabs="false">
      <a id="sliding[B&gt;:SimActor](Int,Int):Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sliding</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>, <span name="step">step: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sliding" data-isabs="false">
      <a id="sliding[B&gt;:SimActor](Int):Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sliding</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#sortBy" data-isabs="false">
      <a id="sortBy[B]((SimActor) ⇒ B)(Ordering[B]):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sortBy</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span name="scala.math.Ordering" class="extype">Ordering</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#sortWith" data-isabs="false">
      <a id="sortWith((SimActor, SimActor) ⇒ Boolean):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sortWith</span>
        
        <span class="params">(<span name="lt">lt: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#sorted" data-isabs="false">
      <a id="sorted[B&gt;:SimActor](Ordering[B]):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sorted</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span name="scala.math.Ordering" class="extype">Ordering</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#span" data-isabs="false">
      <a id="span((SimActor) ⇒ Boolean):(MutableList[SimActor], MutableList[SimActor])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">span</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#splitAt" data-isabs="false">
      <a id="splitAt(Int):(MutableList[SimActor], MutableList[SimActor])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">splitAt</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: (<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](Seq[B],Int):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="offset">offset: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](GenSeq[B],Int):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="offset">offset: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](Seq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](GenSeq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#stringPrefix" data-isabs="false">
      <a id="stringPrefix:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">stringPrefix</span>
        
        <span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#sum" data-isabs="false">
      <a id="sum[B&gt;:SimActor](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">sum</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false">
      <a id="synchronized[T0](⇒ T0):T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">synchronized</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#tail" data-isabs="false">
      <a id="tail:MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">tail</span>
        
        <span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → LinearSeqOptimized → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#tails" data-isabs="false">
      <a id="tails:Iterator[MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">tails</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#take" data-isabs="false">
      <a id="take(Int):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">take</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#takeRight" data-isabs="false">
      <a id="takeRight(Int):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">takeRight</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.LinearSeqOptimized#takeWhile" data-isabs="false">
      <a id="takeWhile((SimActor) ⇒ Boolean):MutableList[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">takeWhile</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scalation.process.Component#tally" data-isabs="false">
      <a id="tally(Double):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">tally</span>
        
        <span class="params">(<span name="duration">duration: <span name="scala.Double" class="extype">Double</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Tally the duration (e.</p><div class="fullcomment"><div class="comment cmt"><p>Tally the duration (e.g., waiting time) of an activity or delay.</p></div><dl class="paramcmts block"><dt class="param">duration</dt><dd class="cmt"><p>the time duration
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="scalation.process.Component" class="extype" href="Component.html">Component</a></dd></dl></div>
    </li><li visbl="prt" name="scala.collection.LinearSeqLike#thisCollection" data-isabs="false">
      <a id="thisCollection:LinearSeq[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">thisCollection</span>
        
        <span class="result">: <span name="scala.collection.LinearSeq" class="extype">LinearSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>LinearSeqLike → SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toArray" data-isabs="false">
      <a id="toArray[B&gt;:SimActor](ClassManifest[B]):Array[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toArray</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: ClassManifest[B]</span>)</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toBuffer" data-isabs="false">
      <a id="toBuffer[B&gt;:SimActor]:Buffer[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toBuffer</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="result">: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.LinearSeqLike#toCollection" data-isabs="false">
      <a id="toCollection(MutableList[SimActor]):LinearSeq[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toCollection</span>
        
        <span class="params">(<span name="repr">repr: <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>)</span><span class="result">: <span name="scala.collection.LinearSeq" class="extype">LinearSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>LinearSeqLike → SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toIndexedSeq" data-isabs="false">
      <a id="toIndexedSeq[B&gt;:SimActor]:IndexedSeq[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toIndexedSeq</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="result">: <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#toIterable" data-isabs="false">
      <a id="toIterable:Iterable[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toIterable</span>
        
        <span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#toIterator" data-isabs="false">
      <a id="toIterator:Iterator[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toIterator</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#toList" data-isabs="false">
      <a id="toList:List[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toList</span>
        
        <span class="result">: <span name="scala.collection.immutable.List" class="extype">List</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toMap" data-isabs="false">
      <a id="toMap[T, U](&lt;:&lt;[SimActor, (T, U)]):Map[T, U]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toMap</span>
        <span class="tparams">[<span name="T">T</span>, <span name="U">U</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="ev">ev: <span name="scala.Predef.&lt;:&lt;" class="extype">&lt;:&lt;</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, (T, U)]</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[T, U]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#toQueue" data-isabs="false">
      <a id="toQueue:Queue[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toQueue</span>
        
        <span class="result">: <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#toSeq" data-isabs="false">
      <a id="toSeq:Seq[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toSeq</span>
        
        <span class="result">: <span name="scala.collection.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toSet" data-isabs="false">
      <a id="toSet[B&gt;:SimActor]:Set[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toSet</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>]</span>
        <span class="result">: <span name="scala.collection.immutable.Set" class="extype">Set</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#toStream" data-isabs="false">
      <a id="toStream:Stream[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toStream</span>
        
        <span class="result">: <span name="scala.collection.immutable.Stream" class="extype">Stream</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#toString" data-isabs="false">
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toString</span>
        
        <span class="params">()</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → TraversableLike → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#toTraversable" data-isabs="false">
      <a id="toTraversable:Traversable[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">toTraversable</span>
        
        <span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.SeqLike#transform" data-isabs="false">
      <a id="transform((SimActor) ⇒ SimActor):WaitQueue.this.type"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">transform</span>
        
        <span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>)</span><span class="result">: WaitQueue.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Traversable#transpose" data-isabs="false">
      <a id="transpose[B]((SimActor) ⇒ TraversableOnce[B]):Traversable[Traversable[B]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">transpose</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asTraversable">asTraversable: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[<span name="scala.collection.Traversable" class="extype">Traversable</span>[B]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Traversable → GenericTraversableTemplate</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#union" data-isabs="false">
      <a id="union[B&gt;:SimActor, That](GenSeq[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">union</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#union" data-isabs="false">
      <a id="union[B&gt;:SimActor, That](Seq[B])(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">union</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#unzip" data-isabs="false">
      <a id="unzip[A1, A2]((SimActor) ⇒ (A1, A2)):(Queue[A1], Queue[A2])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">unzip</span>
        <span class="tparams">[<span name="A1">A1</span>, <span name="A2">A2</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asPair">asPair: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ (A1, A2)</span>)</span><span class="result">: (<span name="scala.collection.mutable.Queue" class="extype">Queue</span>[A1], <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[A2])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#unzip3" data-isabs="false">
      <a id="unzip3[A1, A2, A3]((SimActor) ⇒ (A1, A2, A3)):(Queue[A1], Queue[A2], Queue[A3])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">unzip3</span>
        <span class="tparams">[<span name="A1">A1</span>, <span name="A2">A2</span>, <span name="A3">A3</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asTriple">asTriple: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ (A1, A2, A3)</span>)</span><span class="result">: (<span name="scala.collection.mutable.Queue" class="extype">Queue</span>[A1], <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[A2], <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[A3])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#update" data-isabs="false">
      <a id="update(Int,SimActor):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">update</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>, <span name="x">x: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList → SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#updated" data-isabs="false">
      <a id="updated[B&gt;:SimActor, That](Int,B)(CanBuildFrom[MutableList[SimActor], B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">updated</span>
        <span class="tparams">[<span name="B">B &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="index">index: <span name="scala.Int" class="extype">Int</span></span>, <span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#view" data-isabs="false">
      <a id="view(Int,Int):SeqView[SimActor, MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">view</span>
        
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.SeqView" class="extype">SeqView</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#view" data-isabs="false">
      <a id="view:SeqView[SimActor, MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">view</span>
        
        <span class="result">: <span name="scala.collection.SeqView" class="extype">SeqView</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">wait</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scalation.process.WaitQueue#waitIn" data-isabs="false">
      <a id="waitIn():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">waitIn</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Wait in the queue.</p>
    </li><li visbl="pub" name="scala.collection.TraversableLike#withFilter" data-isabs="false">
      <a id="withFilter((SimActor) ⇒ Boolean):FilterMonadic[SimActor, MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">withFilter</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zip" data-isabs="false">
      <a id="zip[A1&gt;:SimActor, B, That](Iterable[B])(CanBuildFrom[MutableList[SimActor], (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">zip</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Iterable" class="extype">Iterable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zip" data-isabs="false">
      <a id="zip[A1&gt;:SimActor, B, That](GenIterable[B])(CanBuildFrom[MutableList[SimActor], (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">zip</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipAll" data-isabs="false">
      <a id="zipAll[B, A1&gt;:SimActor, That](Iterable[B],A1,B)(CanBuildFrom[MutableList[SimActor], (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">zipAll</span>
        <span class="tparams">[<span name="B">B</span>, <span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Iterable" class="extype">Iterable</span>[B]</span>, <span name="thisElem">thisElem: A1</span>, <span name="thatElem">thatElem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipAll" data-isabs="false">
      <a id="zipAll[B, A1&gt;:SimActor, That](GenIterable[B],A1,B)(CanBuildFrom[MutableList[SimActor], (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">zipAll</span>
        <span class="tparams">[<span name="B">B</span>, <span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>, <span name="thisElem">thisElem: A1</span>, <span name="thatElem">thatElem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipWithIndex" data-isabs="false">
      <a id="zipWithIndex[A1&gt;:SimActor, That](CanBuildFrom[MutableList[SimActor], (A1, Int), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name">zipWithIndex</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>, <span name="That">That</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>], (A1, <span name="scala.Int" class="extype">Int</span>), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#elements" data-isabs="false">
      <a id="elements:Iterator[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">elements</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>iterator' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#equalsWith" data-isabs="false">
      <a id="equalsWith[B](Seq[B])((SimActor, B) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">equalsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="params">(<span name="f">f: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, B) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>corresponds</code> instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#findIndexOf" data-isabs="false">
      <a id="findIndexOf((SimActor) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">findIndexOf</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>Use indexWhere(p) instead.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#findLastIndexOf" data-isabs="false">
      <a id="findLastIndexOf((SimActor) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">findLastIndexOf</span>
        
        <span class="params">(<span name="p">p: (<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>lastIndexWhere</code> instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#first" data-isabs="false">
      <a id="first:SimActor"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">first</span>
        
        <span class="result">: <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>head' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#firstOption" data-isabs="false">
      <a id="firstOption:Option[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">firstOption</span>
        
        <span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>headOption' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#projection" data-isabs="false">
      <a id="projection:SeqView[SimActor, MutableList[SimActor]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">projection</span>
        
        <span class="result">: <span name="scala.collection.SeqView" class="extype">SeqView</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>view' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MutableList#reset" data-isabs="false">
      <a id="reset():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">reset</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MutableList</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use clear() instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#reversedElements" data-isabs="false">
      <a id="reversedElements:Iterator[SimActor]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol"> 
        <span class="name deprecated">reversedElements</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>reverseIterator' instead</code></p></dd></dl></div>
    </li></ol>
            </div>

        <div name="scalation.process.Component" class="parent">
              <h3>Inherited from <a name="scalation.process.Component" class="extype" href="Component.html">Component</a></h3>
            </div><div name="scalation.util.Identity" class="parent">
              <h3>Inherited from <a name="scalation.util.Identity" class="extype" href="../util/Identity.html">Identity</a></h3>
            </div><div name="scalation.util.Error" class="parent">
              <h3>Inherited from <a name="scalation.util.Error" class="extype" href="../util/Error.html">Error</a></h3>
            </div><div name="scala.collection.mutable.Queue" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.mutable.MutableList" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.Serializable" class="parent">
              <h3>Inherited from <span name="scala.Serializable" class="extype">Serializable</span></h3>
            </div><div name="java.io.Serializable" class="parent">
              <h3>Inherited from <span name="java.io.Serializable" class="extype">Serializable</span></h3>
            </div><div name="scala.collection.mutable.Builder" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.generic.Growable" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.Growable" class="extype">Growable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.LinearSeqOptimized" class="parent">
              <h3>Inherited from <span name="scala.collection.LinearSeqOptimized" class="extype">LinearSeqOptimized</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.mutable.LinearSeq" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.LinearSeq" class="extype">LinearSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.LinearSeq" class="parent">
              <h3>Inherited from <span name="scala.collection.LinearSeq" class="extype">LinearSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.LinearSeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.LinearSeqLike" class="extype">LinearSeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.mutable.Seq" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.mutable.SeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.SeqLike" class="extype">SeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.mutable.Cloneable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Cloneable" class="extype">Cloneable</span>[<span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.Seq" class="parent">
              <h3>Inherited from <span name="scala.collection.Seq" class="extype">Seq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.SeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.SeqLike" class="extype">SeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.GenSeq" class="parent">
              <h3>Inherited from <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.GenSeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenSeqLike" class="extype">GenSeqLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.PartialFunction" class="parent">
              <h3>Inherited from <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Int" class="extype">Int</span>, <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.Function1" class="parent">
              <h3>Inherited from (<span name="scala.Int" class="extype">Int</span>) ⇒ <a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a></h3>
            </div><div name="scala.collection.mutable.Iterable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.Iterable" class="parent">
              <h3>Inherited from <span name="scala.collection.Iterable" class="extype">Iterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.IterableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.IterableLike" class="extype">IterableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.Equals" class="parent">
              <h3>Inherited from <span name="scala.Equals" class="extype">Equals</span></h3>
            </div><div name="scala.collection.GenIterable" class="parent">
              <h3>Inherited from <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.GenIterableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenIterableLike" class="extype">GenIterableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.mutable.Traversable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Traversable" class="extype">Traversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.Mutable" class="parent">
              <h3>Inherited from <span name="scala.Mutable" class="extype">Mutable</span></h3>
            </div><div name="scala.collection.Traversable" class="parent">
              <h3>Inherited from <span name="scala.collection.Traversable" class="extype">Traversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.GenTraversable" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversable" class="extype">GenTraversable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.generic.GenericTraversableTemplate" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.GenericTraversableTemplate" class="extype">GenericTraversableTemplate</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>]</h3>
            </div><div name="scala.collection.TraversableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableLike" class="extype">TraversableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.GenTraversableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableLike" class="extype">GenTraversableLike</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.Parallelizable" class="parent">
              <h3>Inherited from <span name="scala.collection.Parallelizable" class="extype">Parallelizable</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.parallel.mutable.ParSeq" class="extype">ParSeq</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.TraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.GenTraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]</h3>
            </div><div name="scala.collection.generic.FilterMonadic" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.MutableList" class="extype">MutableList</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.collection.generic.HasNewBuilder" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.HasNewBuilder" class="extype">HasNewBuilder</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>, <span name="scala.collection.mutable.Queue" class="extype">Queue</span>[<a name="scalation.process.SimActor" class="extype" href="SimActor.html">SimActor</a>]]</h3>
            </div><div name="scala.AnyRef" class="parent">
              <h3>Inherited from AnyRef</h3>
            </div><div name="scala.Any" class="parent">
              <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3>
            </div>

      </div>
      
      <div id="tooltip"></div>
      
    </body>
      </html>